package shuaige.jdk.多线程.concurrent.completableFuture;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class 任意一个完成就返回 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        任意一个完成就返回 任意一个完成就返回 = new 任意一个完成就返回();
        任意一个完成就返回.基本使用();
    }

    public void 基本使用() throws ExecutionException, InterruptedException {
        //创建一个已经有任务结果的CompletableFuture
        CompletableFuture<String> f1 = CompletableFuture.completedFuture("return value");
        //异步处理任务,有返回值
        CompletableFuture<String> f2 = CompletableFuture.supplyAsync(this::get);
        //异步处理任务,没有返回值
        CompletableFuture<Void> f3 = CompletableFuture.runAsync(System.out::println);
        // 任意一个异步任务执行完毕,就会返回一个新的CompletableFuture
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(f1, f2, f3);
        System.out.println(anyOf);
        Object anyOfResult = anyOf.join();
        System.out.println("anyOfResult = " + anyOfResult);
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());

        // 使用流组合结果
        List<?> collect = Stream.of(f1, f2, f3)
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    public String get() {
        delay();
        return "异步任务结果";
    }

    public void delay() {
        try {
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
